/*
 * $Id$
 *
 * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
 * Santa Clara, California 95054, U.S.A. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.jdesktop.swingx.auth;

import java.awt.EventQueue;
import java.util.logging.Logger;

import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.event.EventListenerList;

import org.jdesktop.beans.AbstractBean;

/**
 * <b>LoginService</b> is the abstract base class for all classes implementing
 * a login mechanism. It allows you to customize the threading behaviour used to
 * perform the login. Subclasses need to override the <b>authenticate</b>
 * method. Subclasses may implement the getUserRoles() method to return a
 * meaningful value this method will be called once upon a successful login to
 * determine the user roles. It is not defined as abstract to simplify the task
 * of implementing a login service for those who do not require this
 * functionality.
 * 
 * @author Bino George
 * @author Shai Almog
 * @author Karl Schaefer
 */
public abstract class LoginService extends AbstractBean {
    @SuppressWarnings("unused")
    private Logger LOG = Logger.getLogger(LoginService.class.getName());

    private EventListenerList listenerList = new EventListenerList();

    private SwingWorker<Boolean, Void> loginWorker;

    /*
     * Controls the authentication behaviour to be either synchronous or
     * asynchronous
     */
    private boolean synchronous;

    private String server;

    public LoginService() {
    }

    public LoginService(String server) {
        setServer(server);
    }

    /**
     * This method is intended to be implemented by clients wishing to
     * authenticate a user with a given password. Clients should implement the
     * authentication in a manner that the authentication can be cancelled at
     * any time.
     * 
     * @param name
     *            username
     * @param password
     *            password
     * @param server
     *            server (optional)
     * 
     * @return <code>true</code> on authentication success
     * @throws Exception
     */
    public abstract boolean authenticate(String name, char[] password,
            String server) throws Exception;

    /**
     * Called immediately after a successful authentication. This method should
     * return an array of user roles or null if role based permissions are not
     * used.
     * 
     * @return per default <code>null</code>
     */
    public String[] getUserRoles() {
        return null;
    }

    /**
     * Notifies the LoginService that an already running authentication request
     * should be cancelled. This method is intended to be used by clients who
     * want to provide user with control over cancelling a long running
     * authentication request.
     */
    public void cancelAuthentication() {
        if (loginWorker != null) {
            loginWorker.cancel(true);
        }
    }

    /**
     * This method starts the authentication process and is either synchronous
     * or asynchronous based on the synchronous property
     * 
     * @param user
     *            user
     * @param password
     *            password
     * @param server
     *            server
     * @throws Exception
     */
    public void startAuthentication(final String user, final char[] password,
            final String server) throws Exception {
        if (getSynchronous()) {
            try {
                if (authenticate(user, password, server)) {
                    fireLoginSucceeded(new LoginEvent(this));
                } else {
                    fireLoginFailed(new LoginEvent(this));
                }
            } catch (Throwable e) {
                fireLoginFailed(new LoginEvent(this, e));
            }
        } else {
            loginWorker = new SwingWorker<Boolean, Void>() {
                @Override
                protected Boolean doInBackground() throws Exception {
                    try {
                        final boolean result = authenticate(user, password,
                                server);
                        if (isCancelled()) {
                            EventQueue.invokeLater(new Runnable() {
                                public void run() {
                                    fireLoginCanceled(new LoginEvent(this));
                                }
                            });
                            return false;
                        }
                        EventQueue.invokeLater(new Runnable() {
                            public void run() {
                                if (result) {
                                    fireLoginSucceeded(new LoginEvent(
                                            LoginService.this));
                                } else {
                                    fireLoginFailed(new LoginEvent(
                                            LoginService.this));
                                }
                            }
                        });
                        return result;
                    } catch (final Throwable failed) {
                        if (!isCancelled()) {
                            SwingUtilities.invokeLater(new Runnable() {
                                public void run() {
                                    fireLoginFailed(new LoginEvent(
                                            LoginService.this, failed));
                                }
                            });
                        } else {
                            EventQueue.invokeLater(new Runnable() {
                                public void run() {
                                    fireLoginCanceled(new LoginEvent(this));
                                }
                            });
                        }
                        return false;
                    }
                }
            };
            loginWorker.execute();
            fireLoginStarted(new LoginEvent(this));
        }
    }

    /**
     * Get the synchronous property
     * 
     * @return the synchronous property
     */
    public boolean getSynchronous() {
        return synchronous;
    }

    /**
     * Sets the synchronous property
     * 
     * @param synchronous
     *            synchronous property
     */
    public void setSynchronous(boolean synchronous) {
        boolean old = getSynchronous();
        this.synchronous = synchronous;
        firePropertyChange("synchronous", old, getSynchronous());
    }

    /**
     * Adds a <strong>LoginListener</strong> to the list of listeners
     * 
     * @param listener
     *            listener
     */

    public void addLoginListener(LoginListener listener) {
        listenerList.add(LoginListener.class, listener);
    }

    /**
     * Removes a <strong>LoginListener</strong> from the list of listeners
     * 
     * @param listener
     *            listener
     */
    public void removeLoginListener(LoginListener listener) {
        listenerList.remove(LoginListener.class, listener);
    }

    void fireLoginStarted(final LoginEvent source) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == LoginListener.class) {
                ((LoginListener) listeners[i+1]).loginStarted(source);
            }
        }
    }

    void fireLoginSucceeded(final LoginEvent source) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == LoginListener.class) {
                ((LoginListener) listeners[i+1]).loginSucceeded(source);
            }
        }
    }

    void fireLoginFailed(final LoginEvent source) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == LoginListener.class) {
                ((LoginListener) listeners[i+1]).loginFailed(source);
            }
        }
    }

    void fireLoginCanceled(final LoginEvent source) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == LoginListener.class) {
                ((LoginListener) listeners[i+1]).loginCanceled(source);
            }
        }
    }

    /**
     * @return Returns the server.
     */
    public String getServer() {
        return server;
    }

    /**
     * @param server
     *            The server to set.
     */
    public void setServer(String server) {
        String old = getServer();
        this.server = server;
        firePropertyChange("server", old, getServer());
    }
}
